const router = require('express').Router();
const fs = require('fs').promises; // 使用 promises API
const path = require('path');
const upload = require('../uploadFile/index');
const db = require('../common/db/db');
const express = require('express');
// 统一的响应处理
const sendResponse = (res, code, msg, data = null) => {
    const response = { code, msg };
    if (data) response.data = data;
    res.send(response);
};

//http://localhost:3000/api/upload
//上传banner图片
router.post('/upload', upload.single('photo'), async (req, res) => {
    try {
        let file = req.file;
        // 获取备注参数
        let descr = req.body.descr || ''; // 如果没有传入备注，默认为空字符串
        
        if (!file) {
            return sendResponse(res, -1, '上传文件失败，请检查后再提交');
        }
        console.log('上传文件:', file);
        
        // 构建图片访问URL
        const baseUrl = `${req.protocol}://${req.get('host')}`;
        const picUrl = `/imgs/${file.filename}`;
        const fullUrl = baseUrl + picUrl;

        try {
            // 修改SQL，添加备注字段
            await db.query(
                'INSERT INTO img_banner(img_url, descr) VALUES(?, ?)', 
                [fullUrl, descr]
            );
            
            // 发送成功响应
            sendResponse(res, 200, '上传图片成功', {
                picUrl,
                fullUrl,
                filename: file.filename,
                descr    // 返回备注信息
            });
        } catch (dbError) {
            // 如果数据库操作失败，删除已上传的文件
            const filePath = path.join(__dirname, '../public/imgs', file.filename);
            try {
                await fs.unlink(filePath);
            } catch (unlinkError) {
                console.error('删除文件失败:', unlinkError);
            }
            throw dbError;
        }
    } catch (error) {
        console.error('上传处理错误:', error);
        sendResponse(res, -1, '上传失败: ' + error.message);
    }
});
//删除图片
// 定义删除图片的路由，使用 POST 方法
router.post('/delete', async (req, res) => {
    // 打印请求体内容，方便调试
    console.log('body==>', req.body);

    try {
        // 从请求体中解构出 picUrl 和 dirName，默认值为 'imgs'
        const { picUrl, dirName = 'imgs' } = req.body;

        // 如果没有提供 picUrl 参数，返回错误响应
        if (!picUrl) {
            return sendResponse(res, -1, '缺少参数');
        }

        // 检查 picUrl 是否包含指定的目录名（如 imgs），如果不存在则返回错误
        const index = picUrl.indexOf(dirName);
        if (index === -1) {
            return sendResponse(res, 404, '该路径找不到图片资源');
        }

        // 构建文件的完整路径
        const filePath = path.join(__dirname, '../public/', picUrl.slice(index));

        try {
            // 检查文件是否存在
            await fs.access(filePath);
            // 删除文件
            await fs.unlink(filePath);

            // 从数据库中删除对应的记录，使用 LIKE 查询匹配 picUrl
            await db.query('DELETE FROM img_banner WHERE img_url LIKE ?', [`%${picUrl}`]);

            // 返回删除成功的响应
            sendResponse(res, 200, '删除图片成功');
        } catch (error) {
            // 如果文件不存在，返回特定错误信息
            if (error.code === 'ENOENT') {
                return sendResponse(res, 404, '文件不存在');
            }
            // 抛出其他错误以便外层捕获
            throw error;
        }
    } catch (error) {
        // 打印错误日志
        console.error('删除文件错误:', error);
        // 返回通用的删除失败响应
        sendResponse(res, -1, '删除图片失败: ' + error.message);
    }
});
//修改图片信息
//http://localhost:3000/api/amend
router.post('/amend', upload.single('photo'), async (req, res) => {
    try {
        console.log('请求信息:', {
            headers: req.headers,
            body: req.body,
            file: req.file
        });
        
        const oldImgUrl = req.body.img_url;
        const descr = req.body.descr;
        const file = req.file;

        if (!oldImgUrl) {
            return sendResponse(res, -1, '缺少原图片URL参数');
        }

        // 如果没有上传新图片，使用原图片URL
        let fullUrl = oldImgUrl;
        let picUrl = oldImgUrl.substring(oldImgUrl.indexOf('/imgs'));

        if (file) {
            // 有新图片时才删除旧图片
            const index = oldImgUrl.indexOf('imgs');
            if (index !== -1) {
                const oldFilePath = path.join(__dirname, '../public/', oldImgUrl.slice(index));
                try {
                    await fs.access(oldFilePath);
                    await fs.unlink(oldFilePath);
                } catch (error) {
                    console.error('删除旧文件失败:', error);
                }
            }

            // 构建新图片URL
            const baseUrl = `${req.protocol}://${req.get('host')}`;
            picUrl = `/imgs/${file.filename}`;
            fullUrl = baseUrl + picUrl;
        }

        // 更新数据库记录
        await db.query(
            'UPDATE img_banner SET img_url = ?, descr = ? WHERE img_url = ?',
            [fullUrl, descr, oldImgUrl]
        );
        
        sendResponse(res, 200, '更新成功', {
            img_url: fullUrl,
            picUrl,
            filename: file ? file.filename : picUrl.split('/').pop(),
            descr
        });
    } catch (error) {
        // 如果出错且上传了新文件，删除新文件
        if (req.file) {
            const filePath = path.join(__dirname, '../public/imgs', req.file.filename);
            try {
                await fs.unlink(filePath);
            } catch (unlinkError) {
                console.error('删除新文件失败:', unlinkError);
            }
        }
        console.error('处理请求错误:', error);
        sendResponse(res, -1, '更新失败: ' + error.message);
    }
});


module.exports = router;